package com.cloud.pole.weixin.util.wechat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.net.ssl.HttpsURLConnection;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.dom4j.DocumentException;


public class CommonRequest {
    
    private static String charset = "UTF-8";
    private static Integer connectTimeout = null;
    private static Integer socketTimeout = null;
    private static String proxyHost = null;
    private static Integer proxyPort = null;
	    
    public static String postString(String urlStr,String strMsg) throws IOException, DocumentException {  
    	StringBuilder buffer = new StringBuilder();
		URL url = new URL(urlStr);  
		HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();
		httpUrlConn.setDoOutput(true);
		httpUrlConn.setRequestMethod("POST");
//		Document document = DocumentHelper.parseText(xmlStr);
//		xmlStr = document.asXML();
		OutputStreamWriter 
			outputStream = new OutputStreamWriter(httpUrlConn.getOutputStream(),"UTF-8");
			outputStream.write(strMsg);
		outputStream.close();
		InputStream inputStream = httpUrlConn.getInputStream();  
		InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "UTF-8");  
		//inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
		BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
		String str = null;  
        while ((str = bufferedReader.readLine()) != null) {  
            buffer.append(str);  
        }  
        bufferedReader.close();  
        inputStreamReader.close();  
        // 释放资源  
        inputStream.close();  
        inputStream = null;  
        httpUrlConn.disconnect();
        return buffer.toString();
    }  
    
    public static String doGet(String url) throws Exception {
        
        URL localURL = new URL(url);
        
        URLConnection connection = openConnection(localURL);
        HttpURLConnection httpURLConnection = (HttpURLConnection)connection;
        
        httpURLConnection.setRequestProperty("Accept-Charset", charset);
        httpURLConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
        
        InputStream inputStream = null;
        InputStreamReader inputStreamReader = null;
        BufferedReader reader = null;
        StringBuffer resultBuffer = new StringBuffer();
        String tempLine = null;
        
        if (httpURLConnection.getResponseCode() >= 300) {
            throw new Exception("HTTP Request is not success, Response code is " + httpURLConnection.getResponseCode());
        }
        try {
            inputStream = httpURLConnection.getInputStream();
            inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
            //inputStreamReader = new InputStreamReader(inputStream);
            reader = new BufferedReader(inputStreamReader);
            
            while ((tempLine = reader.readLine()) != null) {
                resultBuffer.append(tempLine);
            }
            
        } finally {
            
            if (reader != null) {
                reader.close();
            }
            
            if (inputStreamReader != null) {
                inputStreamReader.close();
            }
            
            if (inputStream != null) {
                inputStream.close();
            }
            
        }

        return resultBuffer.toString();
    }
	    
    /**
     * Do POST request
     * @param url
     * @param parameterMap
     * @return
     * @throws Exception 
     */
    public static byte[] doPostJsonToBytes(String pathUrl, String strJson) throws Exception {
    	byte[] bResult = null;
		try { 
			HttpClient httpClient = HttpClients.createDefault();
			HttpPost httpPost = new HttpPost(pathUrl);
			RequestConfig requestConfig = RequestConfig.custom()
	                .setConnectTimeout(50000).setConnectionRequestTimeout(10000)
	                .setSocketTimeout(50000).build();
			httpPost.setConfig(requestConfig);
	        httpPost.setHeader("Content-Type", "application/json");
	        httpPost.setEntity(new StringEntity(strJson, ContentType.create("application/json", "utf-8")));
	        System.out.println("request parameters" + EntityUtils.toString(httpPost.getEntity()));
	        System.out.println("httpPost:" + httpPost);
	        HttpResponse response = httpClient.execute(httpPost);
	        if (response != null && response.getStatusLine().getStatusCode() == 200) {
	        	bResult = EntityUtils.toByteArray(response.getEntity());
	        }
		} catch (Exception ex) { 
    		ex.printStackTrace(); 
		}
		return bResult; 
    }
    
    private static URLConnection openConnection(URL localURL) throws IOException {
        URLConnection connection;
        if (proxyHost != null && proxyPort != null) {
            Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyHost, proxyPort));
            connection = localURL.openConnection(proxy);
        } else {
            connection = localURL.openConnection();
        }
        return connection;
    }
    
    /**
     * Render request according setting
     * @param request
     */
    private void renderRequest(URLConnection connection) {
        
        if (connectTimeout != null) {
            connection.setConnectTimeout(connectTimeout);
        }
        
        if (socketTimeout != null) {
            connection.setReadTimeout(socketTimeout);
        }
    }

    /*
     * Getter & Setter
     */
    public Integer getConnectTimeout() {
        return connectTimeout;
    }

    public void setConnectTimeout(Integer connectTimeout) {
        this.connectTimeout = connectTimeout;
    }

    public Integer getSocketTimeout() {
        return socketTimeout;
    }

    public void setSocketTimeout(Integer socketTimeout) {
        this.socketTimeout = socketTimeout;
    }

    public String getProxyHost() {
        return proxyHost;
    }

    public void setProxyHost(String proxyHost) {
        this.proxyHost = proxyHost;
    }

    public Integer getProxyPort() {
        return proxyPort;
    }

    public void setProxyPort(Integer proxyPort) {
        this.proxyPort = proxyPort;
    }

    public String getCharset() {
        return charset;
    }

    public void setCharset(String charset) {
        this.charset = charset;
    }
}
